from collections import deque
import random

#二叉搜索树的插入
class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                #self.insert_no_re(val)
                self.root = self.insert(self.root, val)

    def insert(self, node, val):  #递归方法
        if not node:
            node = BiTreeNode(val)
        if val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node
    
    def insert_no_re(self, val): #非递归方法
        p = self.root
        if not p:
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def pre_order(self, root):
        if root:
            print(root.data, end = ",")
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self,root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end = ',')
            self.in_order(root.rchild)


    def post_order(self, root):
        if root:
            self.in_order(root.lchild)
            self.in_order(root.rchild)
            print(root.data, end = ',')

    def level_order(self, root):
        queue = deque()
        queue.append(root)
        while len(queue) > 0: #只要队列不为空
            node = queue.popleft()
            print(node.data, end = ',')
            if node.lchild:
                queue.append(node.lchild)
            if node.rchild:
                queue.append(node.rchild)

    def __remove_node_1(self, node):
        #情况1：node是叶子节点
        if not node.parent:  #node是根节点的情况
            self.root = None
        if node == node.parent.lchild: #node是它父亲的左孩子
            node.parent.lchild = None
        else: #右孩子
            node.parent.rchild = None
        
    def __remove_node_21(self, node):
        #情况2.1：node只有一个左孩子
        if not node.parent: #根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        #情况2.2：node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
            node.rchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:  # 不是空树
            node = self.query_no_rec(val)
            if not node: # 不存在
                return False
            if not node.lchild and not node.rchild:
                self.__remove_node_1(node)
            elif not node.rchild: #2.1只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild: #2.2只有一个右孩子
                self.__remove_node_22(node)
            else:
                #3. 两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                #删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)

    def query(self, node, val):  #查询，递归方法 递归方法需要有node，node是递归用的
        if not node:
            return None
        if val < node.data:
            return self.query(node.lchild, val)
        elif val > node.data:
            return self.query(node.rchild, val)
        else:
            return node

    def query_no_rec(self, val):  #查询，非递归
        p = self.root
        if not p:
            return None
        while p:
            if val < p.data:
                p = p.lchild
            elif val > p.data:
                p = p.rchild
            else:
                return p
        return None


# li = list(range(0,500,2))
# random.shuffle(li)

# tree = BST(li)

# tree.in_order(tree.root)
# print("")

# print(tree.query_no_rec(3))


tree = BST([1,4,2,5,3,8,6,9,7])
tree.in_order(tree.root)
print("")

tree.delete(4)
tree.in_order(tree.root)
print("")
tree.delete(1)
tree.in_order(tree.root)